import numpy as np
from numpy.core.fromnumeric import shape
from numpy.lib.function_base import copy
# https://blog.csdn.net/a373595475/article/details/79580734


def numpy_array():
    # numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)
    # 1.object 任何暴露数组接口方法的对象都会返回一个数组或任何（嵌套）序列。
    # 2.dtype 数组的所需数据类型，可选。
    # 3.copy 可选，默认为true，对象是否被复制。
    # 4.order C（按行）、F（按列）或A（任意，默认）。
    # 5.subok 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类。
    # 6.ndmin 指定返回数组的最小维数。
    a = np.array([1, 2, 3])
    print(a)
    # 二维数组
    b = np.array([[1, 2], [3, 4]])
    print(b)
    # 最小维度
    a = np.array([1, 2, 3, 4, 5], ndmin=2)
    print(a)
    # dtype参数
    a = np.array([1, 2, 3, ], dtype=complex)
    print(a)


def numpy_dtype():
    # numpy.dtype(object,align,copy)
    # object：被转换为数据类型的对象。
    # align：如果为true，则向字段添加间隔，使其类似 C 的结构体。
    # copy: 生成dtype对象的新副本，如果为flase，结果是内建数据类型对象的引用。
    # 使用数组标量类型
    dt = np.dtype(np.int32)
    print(dt)
    # int8,int16,int32,int64可以替换为等价的字符串 'i1','i2','i4',以及其他。
    dt = np.dtype('i4')
    print(dt)
    # 使用端记号
    dt = np.dtype('>i4')
    print(dt)
    # 下面的例子展示了结构化数据类型的使用。 这里声明了字段名称和相应的标量数据类型。
    # 首先创建结构化数据类型
    dt = np.dtype([('age', np.int8)])
    print(dt)
    # 将其运用于ndarray对象
    a = np.array([(10,), (20,), (30,)], dtype=dt)
    print(a)
    # 访问age列的内容
    print(a['age'])
    # 以下示例定义名为 student 的结构化数据类型，其中包含字符串字段name，整数字段age和浮点字段marks。 此dtype应用于ndarray对象。
    student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
    print(student)
    a = np.array([('abc', 21, 50), ('xyz', 18, 750)], dtype=student)
    print(a)
    # 每个内建类型都有一个唯一定义它的字符代码：
    # 'b'：布尔值、'i'：符号整数、'u'：无符号整数、'f'：浮点、'c'：复数浮点、'm'：时间间隔
    # 'M'：日期时间、'O'：Python 对象、'S', 'a'：字节串、'U'：Unicode、'V'：原始数据（void）


def numpy_shape():
    # 数组属性
    a = np.array([[1, 2, 3], [4, 5, 6]])
    # 返回一个包含数组维度的元组，它也可以用于调整数组大小。
    print(a.shape)
    # 跳针数组大小
    a.shape = (3, 2)
    b = a.reshape(3, 2)
    print(a)
    print(b)


def numpy_ndim():
    # 等间隔数字数组
    a = np.arange(24)
    print(a)
    print(a.ndim)
    # 调整数组大小,三个维度
    b = a.reshape(2, 3, 4)
    print(b)


def numpy_itemsize():
    # 这一数组属性返回数组中每个元素的字节单位长度。
    x = np.array([1, 2, 3, 4, 5], dtype=np.int8)
    print(x.itemsize)
    x = np.array([1, 2, 3, 4, 5], dtype=np.float32)
    print(x.itemsize)


def numpy_flages():
    # 1.C_CONTIGUOUS(C) 数组位于单一的、C 风格的连续区段内
    # 2.F_CONTIGUOUS(F) 数组位于单一的、Fortran 风格的连续区段内
    # 3.OWNDATA(O)      数组的内存从其它对象处借用
    # 4.WRITEABLE(W)    数据区域可写入。 将它设置为flase会锁定数据，使其只读
    # 5.ALIGNED(A)      数据和任何元素会为硬件适当对齐
    # 6.UPDATEIFCOPY(U) 这个数组是另一数组的副本。当这个数组释放时，源数组会由这个数组中的元素更新
    x = np.array([1, 2, 3, 4, 5])
    print(x.flags)


def numpy_empty():
    # 创建指定形状和dtype的未初始化数组
    # numpy.empty(shape,dtype=float,order='C')
    # 1.Shape 空数组的形状，整数或整数元组
    # 2.Dtype 所需的输出数组类型，可选
    # 3.Order 'C'为按行的 C 风格数组，'F'为按列的 Fortran 风格数组
    # 注意：数组元素为随机值，因为它们未初始化。
    x = np.empty([3, 2], dtype=int)
    print(x)


def numpy_zeros():
    # 返回特定大小，以0填充的新数组
    # numpy.zeros(shape,dtype=float,order='C')
    # 含有5个0的数组，默认类型为float
    x = np.zeros(5)
    print(x)
    x = np.zeros((5,), dtype=np.int8)
    print(x)
    # 自定义类型
    x = np.zeros((2, 2), dtype=[('x', 'i4'), ('y', 'i4')])
    print(x)


def numpy_ones():
    # 返回特定大小，以1填充的新数组
    # numpy.zeros(shape,dtype=float,order='C')
    x = np.ones(5)
    print(x)
    x = np.ones([2, 2], dtype=int)
    print(x)


def numpy_asarray():
    # numpy.asarry(a,np.dtype=None,order=None)
    # 1.a 任意形式的输入参数，比如列表、列表的元组、元组、元组的元组、元组的列表
    # 2.dtype 通常，输入数据的类型会应用到返回的ndarray
    # 3.order 'C'为按行的 C 风格数组，'F'为按列的 Fortran 风格数组
    # 将列表转化为ndarray
    x = [1, 2, 3]
    a = np.asarray(x)
    print(a)
    a = np.asarray(x, dtype=float)
    print(a)
    # 将元组转化为ndarray
    x = (1, 2, 3)
    a = np.asarray(x)
    print(a)
    x = [(1, 2, 3), (4, 5)]
    a = np.asarray(x)
    print(a)


def numpy_frombuffer():
    # 将缓冲区解释为一维数组。 暴露缓冲区接口的任何对象都用作参数来返回ndarray。\
    # numpy.frombuffer(buffer,dtype=float,count=-1 offset=0)
    # 1.buffer 任何暴露缓冲区借口的对象
    # 2.dtype 返回数组的数据类型，默认为float
    # 3.count 需要读取的数据数量，默认为-1，读取所有数据
    # 4.offset 需要读取的起始位置，默认为0
    s = 'hello world'
    a = np.frombuffer(s, dtype='S1')
    print(a)


def numpy_fromiter():
    # numpy.fromiter(iterable,dtype,count=-1)
    # 1.iterable 任何可迭代对象
    # 2.dtype 返回数组的数据类型
    # 3.count 需要读取的数据数量，默认为-1，读取所有数据
    # 使用range函数创建列表对象,获得迭代器
    list = range(5)
    it = iter(list)
    x = np.fromiter(it, dtype=float)
    print(x)


def numpy_arange():
    # numpy.arange(start,stop,step,dtype) 这个函数返回ndarray对象，包含给定范围内的等间隔值。
    # 1.start 范围的起始值，默认为0
    # 2.stop 范围的终止值（不包含）
    # 3.step 两个值的间隔，默认为1
    # 4.dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
    x = np.arange(5)
    print(x)
    x = np.arange(5, dtype=float)
    print(x)
    x = np.arange(10, 20, 2)
    print(x)


def numpy_linspace():
    # numpy.linspace(start,stop,num,endpoint,retstep,dtype)函数类似于arange()函数。 在此函数中，指定了范围之间的均匀间隔数量，而不是步长。
    # 1.start 序列的起始值
    # 2.stop 序列的终止值，如果endpoint为true，该值包含于序列中
    # 3.num 要生成的等间隔样例数量，默认为50
    # 4.endpoint 序列中是否包含stop值，默认为ture
    # 5.retstep 如果为true，返回样例，以及连续数字之间的步长
    # 6.dtype 输出ndarray的数据类型
    x = np.linspace(10, 20, 5)
    print(x)
    x = np.linspace(10, 20, 5, endpoint=False)
    print(x)
    x = np.linspace(1, 2, 5, retstep=True)
    print(x)


def numpy_logspace():
    # numpy.logspace(start,stop,num,endpoint,base,dtype)函数返回一个ndarray对象，其中包含在对数刻度上均匀分布的数字。 刻度的开始和结束端点是某个底数的幂，通常为 10。
    # 默认底数为10
    a = np.logspace(1.0, 2.0, num=10)
    print(a)
    a = np.logspace(1, 10, num=10, base=2)
    print(a)
    pass


if __name__ == '__main__':
    numpy_array()
    numpy_dtype()
    numpy_shape()
    numpy_ndim()
    numpy_itemsize()
    numpy_flages()
    numpy_empty()
    numpy_zeros()
    numpy_ones()
    numpy_asarray()
    numpy_frombuffer()
    numpy_fromiter()
    numpy_arange()
    numpy_linspace()
    numpy_logspace()
